/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.escom.healthlc.controller;

import com.escom.healthlc.business.ParentescoBusiness;
import com.escom.healthlc.entidad.ParentescoVO;
import com.escom.healthlc.utils.Constantes;
import com.escom.healthlc.utils.LazySorterParentesco;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import org.primefaces.model.LazyDataModel;
import org.primefaces.model.SortOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author LAURA
 */
@ManagedBean(name = "ParentescoController")
@ViewScoped
public class ParentescoController {

    private static final Logger logger = LoggerFactory.getLogger(ParentescoController.class);

    private List<ParentescoVO> retrieveParentesco;
    private ParentescoVO selectedParentesco;
    private ParentescoVO createParentesco;
    private ParentescoVO parentescoCurrent;
    private LazyDataModel<ParentescoVO> modelParentesco;
    private boolean renderPanelAlta;
    private boolean renderPanelConsulta;
    private boolean pageComplete;

    @ManagedProperty("#{ParentescoBusiness}")
    private ParentescoBusiness parentescoBusiness;

    public ParentescoController() {
    }

    @PostConstruct
    private void initParentescoController() {
        executeLimpiarObejects(null);
    }

    public void executeCrearParentesco(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        parentescoBusiness.crearParentesco(createParentesco);
        int estado = parentescoBusiness.getEstado();
        String messageEstado = parentescoBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_ERROR, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }

        executeLimpiarObejects(acEvt);
    }

    public void executeConsultarParentesco(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        retrieveParentesco = parentescoBusiness.obtenerParentesco();
        logger.debug("Size {}", retrieveParentesco.size());

        if (retrieveParentesco == null) {
            retrieveParentesco = new ArrayList<ParentescoVO>();
        }
        modelParentesco = crearLazyModelParentesco();
        int estado = parentescoBusiness.getEstado();
        String messageEstado = parentescoBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }
        executeChangeToRetrieve();
    }

    public void executeActualizarParentesco(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        parentescoBusiness.actualizarParentesco(selectedParentesco);
        int estado = parentescoBusiness.getEstado();
        String messageEstado = parentescoBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }
        executeLimpiarObejects(acEvt);
    }

    public void executeEliminarParentesco(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        parentescoBusiness.eliminarParentesco(selectedParentesco);
        int estado = parentescoBusiness.getEstado();
        String messageEstado = parentescoBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }
        executeLimpiarObejects(acEvt);
    }

    private LazyDataModel<ParentescoVO> crearLazyModelParentesco() {
        LazyDataModel<ParentescoVO> lazyDataReturn = new LazyDataModel<ParentescoVO>() {
            List<ParentescoVO> datasource = retrieveParentesco;

            @Override
            public ParentescoVO getRowData(String rowKey) {
                for (ParentescoVO parentesco : datasource) {
                    if (parentesco.getTipoParentesco().equals(rowKey)) {
                        return parentesco;
                    }
                }
                return null;
            }

            @Override
            public List<ParentescoVO> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String, String> filters) {
                List<ParentescoVO> data = new ArrayList<>();

                //filter  
                for (ParentescoVO parentesco : datasource) {
                    boolean match = true;
                    for (Iterator<String> it = filters.keySet().iterator(); it.hasNext();) {
                        try {
                            String filterProperty = it.next();
                            Field field;
                            String filterValue = "";
                            String fieldValue;
                            field = parentesco.getClass().getDeclaredField(filterProperty);
                            field.setAccessible(true);
                            filterValue = filters.get(filterProperty);
                            fieldValue = String.valueOf(field.get(parentesco));

                            if (filterValue == null || fieldValue.contains(filterValue)) {
                                match = true;
                            } else {
                                match = false;
                                break;
                            }
                        } catch (Exception e) {
                            match = false;
                        }
                    }

                    if (match) {
                        data.add(parentesco);
                    }
                }

//                sort  
                if (sortField != null) {
                    Collections.sort(data, new LazySorterParentesco(sortField, sortOrder));
                }
                if (sortField == null) {
                    sortField = "defaultSortField";
                }
                //rowCount  
                int dataSize = data.size();
                this.setRowCount(dataSize);

                //paginate  
                if (dataSize > pageSize) {
                    try {
                        return data.subList(first, first + pageSize);
                    } catch (IndexOutOfBoundsException e) {
                        return data.subList(first, first + (dataSize % pageSize));
                    }
                } else {
                    return data;
                }
            }

            @Override
            public Object getRowKey(ParentescoVO t) {
                return t.getIdParentesco();
            }
        };
        return lazyDataReturn;
    }

    public void executeLimpiarObejects(ActionEvent acEvt) {
        retrieveParentesco = new ArrayList<>();
        createParentesco = new ParentescoVO();
        renderPanelAlta = false;
        renderPanelConsulta = false;
    }

    public void executeChangeToCreate() {
        renderPanelAlta = true;
        renderPanelConsulta = false;
    }

    public void executeChangeToRetrieve() {
        renderPanelAlta = false;
        renderPanelConsulta = true;
    }

    public boolean isRenderPanelAlta() {
        return renderPanelAlta;
    }

    public void setRenderPanelAlta(boolean renderPanelAlta) {
        this.renderPanelAlta = renderPanelAlta;
    }

    public boolean isRenderPanelConsulta() {
        return renderPanelConsulta;
    }

    public void setRenderPanelConsulta(boolean renderPanelConsulta) {
        this.renderPanelConsulta = renderPanelConsulta;
    }

    public ParentescoVO getSelectedParentesco() {
        return selectedParentesco;
    }

    public void setSelectedParentesco(ParentescoVO selectedParentesco) {
        this.selectedParentesco = selectedParentesco;
    }

    public ParentescoVO getCreateParentesco() {
        return createParentesco;
    }

    public void setCreateParentesco(ParentescoVO createParentesco) {
        this.createParentesco = createParentesco;
    }

    public LazyDataModel<ParentescoVO> getModelParentesco() {
        return modelParentesco;
    }

    public void setModelParentesco(LazyDataModel<ParentescoVO> modelParentesco) {
        this.modelParentesco = modelParentesco;
    }

    public ParentescoBusiness getParentescoBusiness() {
        return parentescoBusiness;
    }

    public void setParentescoBusiness(ParentescoBusiness parentescoBusiness) {
        this.parentescoBusiness = parentescoBusiness;
    }

}
